//auto gen by paipai.java.augogen ver 3.0.0
//author skyzhuang
//source idl: com.erp.storage.dao.idl.StockCheckMasterDdo.java


#ifndef ERP_STORAGE_DDO_CSTOCKCHECKITEMDDO_BY_AUTOGEN_V5_H
#define ERP_STORAGE_DDO_CSTOCKCHECKITEMDDO_BY_AUTOGEN_V5_H


#include "app_platform/intf_serializable.h"
#include <bitset>
#include <string>
#include <sstream>
#include <iostream>


namespace erp
{
namespace storage
{
namespace ddo
{


class CStockCheckItemDdo : public ISerializable
{
	public:
		std::string m_sLastErrMsg;///<错误信息

		/**
		 *  版本号   
		 *
		 * 版本 >= 0
		 */
		uint32_t dwVersion;

		/**
		 * cVersion_u uflag field
		 */
		uint8_t cVersion_u; //optional flag

		/**
		 * 库存盘点明细SysNo
		 *
		 * 版本 >= 0
		 */
		uint64_t ddwStockCheckItemSysNo;

		/**
		 * cStockCheckItemSysNo_u uflag field
		 */
		uint8_t cStockCheckItemSysNo_u; //optional flag

		/**
		 * 商品SysNo
		 *
		 * 版本 >= 0
		 */
		uint64_t ddwProductSysNo;

		/**
		 * cProductSysNo_u uflag field
		 */
		uint8_t cProductSysNo_u; //optional flag

		/**
		 * 盘点单SysNo
		 *
		 * 版本 >= 0
		 */
		uint64_t ddwStockCheckMasterSysNo;

		/**
		 * cStockCheckMasterSysNo_u uflag field
		 */
		uint8_t cStockCheckMasterSysNo_u; //optional flag

		/**
		 * 库位SysNo
		 *
		 * 版本 >= 0
		 */
		uint64_t ddwStorageSysNo;

		/**
		 * cStorageSysNo_u uflag field
		 */
		uint8_t cStorageSysNo_u; //optional flag

		/**
		 * 盘点数量
		 *
		 * 版本 >= 0
		 */
		uint32_t dwCheckQty;

		/**
		 * cCheckQty_u uflag field
		 */
		uint8_t cCheckQty_u; //optional flag

		/**
		 * 商品成本价
		 *
		 * 版本 >= 0
		 */
		uint64_t ddwCostPrice;

		/**
		 * cCostPrice_u uflag field
		 */
		uint8_t cCostPrice_u; //optional flag

		/**
		 * 商品成本总价
		 *
		 * 版本 >= 0
		 */
		uint64_t ddwCostAmount;

		/**
		 * cCostAmount_u uflag field
		 */
		uint8_t cCostAmount_u; //optional flag

		/**
		 * 库存数量
		 *
		 * 版本 >= 0
		 */
		uint32_t dwStockQty;

		/**
		 * cStockQty_u uflag field
		 */
		uint8_t cStockQty_u; //optional flag

		/**
		 * 仓位空间
		 *
		 * 版本 >= 0
		 */
		std::string strCargoSpace;

		/**
		 * cCargoSpace_u uflag field
		 */
		uint8_t cCargoSpace_u; //optional flag

		/**
		 * 创建时间
		 *
		 * 版本 >= 0
		 */
		uint32_t dwRowCreatDate;

		/**
		 * cRowCreatDate_u uflag field
		 */
		uint8_t cRowCreatDate_u; //optional flag

		/**
		 * 创建人SysNo
		 *
		 * 版本 >= 0
		 */
		uint64_t ddwCreatorSysNo;

		/**
		 * cCreatorSysNo_u uflag field
		 */
		uint8_t cCreatorSysNo_u; //optional flag

		/**
		 * 修改人SysNo
		 *
		 * 版本 >= 0
		 */
		uint64_t ddwModifyUserSysNo;

		/**
		 * cModifyUserSysNo_u uflag field
		 */
		uint8_t cModifyUserSysNo_u; //optional flag

		/**
		 * 修改时间
		 *
		 * 版本 >= 0
		 */
		uint32_t dwModifyTime;

		/**
		 * cModifyTime_u uflag field
		 */
		uint8_t cModifyTime_u; //optional flag

		/**
		 * 盘点明细状态
		 *
		 * 版本 >= 0
		 */
		uint32_t dwStockCheckItemStatus;

		/**
		 * cStockCheckItemStatus_u uflag field
		 */
		uint8_t cStockCheckItemStatus_u; //optional flag

		/**
		 * 盘点明细属性,只读
		 *
		 * 版本 >= 0
		 */
		std::bitset<32>  bitsetStockCheckItemProperty;

		/**
		 * cStockCheckItemProperty_u uflag field
		 */
		uint8_t cStockCheckItemProperty_u; //optional flag

		/**
		 * 盘点明细属性,设置
		 *
		 * 版本 >= 0
		 */
		std::bitset<32>  bitsetStockCheckItemPropertyInclude;

		/**
		 * cStockCheckItemPropertyInclude_u uflag field
		 */
		uint8_t cStockCheckItemPropertyInclude_u; //optional flag

		/**
		 * 盘点明细属性,取消
		 *
		 * 版本 >= 0
		 */
		std::bitset<32>  bitsetStockCheckItemPropertyExclude;

		/**
		 * cStockCheckItemPropertyExclude_u uflag field
		 */
		uint8_t cStockCheckItemPropertyExclude_u; //optional flag




	public:
		CStockCheckItemDdo():
		dwVersion(0),
		cVersion_u(0),
		ddwStockCheckItemSysNo(0),
		cStockCheckItemSysNo_u(0),
		ddwProductSysNo(0),
		cProductSysNo_u(0),
		ddwStockCheckMasterSysNo(0),
		cStockCheckMasterSysNo_u(0),
		ddwStorageSysNo(0),
		cStorageSysNo_u(0),
		dwCheckQty(0),
		cCheckQty_u(0),
		ddwCostPrice(0),
		cCostPrice_u(0),
		ddwCostAmount(0),
		cCostAmount_u(0),
		dwStockQty(0),
		cStockQty_u(0),
		cCargoSpace_u(0),
		dwRowCreatDate(0),
		cRowCreatDate_u(0),
		ddwCreatorSysNo(0),
		cCreatorSysNo_u(0),
		ddwModifyUserSysNo(0),
		cModifyUserSysNo_u(0),
		dwModifyTime(0),
		cModifyTime_u(0),
		dwStockCheckItemStatus(0),
		cStockCheckItemStatus_u(0),
		cStockCheckItemProperty_u(0),
		cStockCheckItemPropertyInclude_u(0),
		cStockCheckItemPropertyExclude_u(0) {}
				CStockCheckItemDdo& operator = (const CStockCheckItemDdo& obj){

			this->dwVersion = obj.dwVersion;
			this->ddwStockCheckItemSysNo = obj.ddwStockCheckItemSysNo;
			this->ddwProductSysNo = obj.ddwProductSysNo;
			this->ddwStockCheckMasterSysNo = obj.ddwStockCheckMasterSysNo;
			this->ddwStorageSysNo = obj.ddwStorageSysNo;
			this->dwCheckQty = obj.dwCheckQty;
			this->ddwCostPrice = obj.ddwCostPrice;
			this->ddwCostAmount = obj.ddwCostAmount;
			this->dwStockQty = obj.dwStockQty;
			this->strCargoSpace = obj.strCargoSpace;
			this->dwRowCreatDate = obj.dwRowCreatDate;
			this->ddwCreatorSysNo = obj.ddwCreatorSysNo;
			this->ddwModifyUserSysNo = obj.ddwModifyUserSysNo;
			this->dwModifyTime = obj.dwModifyTime;
			this->dwStockCheckItemStatus = obj.dwStockCheckItemStatus;
			this->bitsetStockCheckItemProperty = obj.bitsetStockCheckItemProperty;
			this->bitsetStockCheckItemPropertyInclude = obj.bitsetStockCheckItemPropertyInclude;
			this->bitsetStockCheckItemPropertyExclude = obj.bitsetStockCheckItemPropertyExclude;
			this->cVersion_u = obj.cVersion_u;
			this->cStockCheckItemSysNo_u = obj.cStockCheckItemSysNo_u;
			this->cProductSysNo_u = obj.cProductSysNo_u;
			this->cStockCheckMasterSysNo_u = obj.cStockCheckMasterSysNo_u;
			this->cStorageSysNo_u = obj.cStorageSysNo_u;
			this->cCheckQty_u = obj.cCheckQty_u;
			this->cCostPrice_u = obj.cCostPrice_u;
			this->cCostAmount_u = obj.cCostAmount_u;
			this->cStockQty_u = obj.cStockQty_u;
			this->cCargoSpace_u = obj.cCargoSpace_u;
			this->cRowCreatDate_u = obj.cRowCreatDate_u;
			this->cCreatorSysNo_u = obj.cCreatorSysNo_u;
			this->cModifyUserSysNo_u = obj.cModifyUserSysNo_u;
			this->cModifyTime_u = obj.cModifyTime_u;
			this->cStockCheckItemStatus_u = obj.cStockCheckItemStatus_u;
			this->cStockCheckItemProperty_u = obj.cStockCheckItemProperty_u;
			this->cStockCheckItemPropertyInclude_u = obj.cStockCheckItemPropertyInclude_u;
			this->cStockCheckItemPropertyExclude_u = obj.cStockCheckItemPropertyExclude_u;
			return *this;
		}

	public:


		/**
		 * 是否设置 版本号   了
		 * 
		 * @param uint32_t:dwVersion
		 *  
		 * 
		 */
		 bool  IsVersionSet() const{
				 return  cVersion_u != 0;
		}


		/**
		 * 获取uflag 版本号   了
		 * 
		 * @param uint32_t:dwVersion
		 *  
		 * 
		 */
		 const uint8_t   GetVersionUFlag() const{
				 return  cVersion_u;
		}


		/**
		 * 设置 版本号   
		 * 
		 * @param uint32_t:dwVersion
		 *  
		 * 
		 */
		 void  SetVersion( const uint32_t& sVal, uint8_t cUFlag=1){
				dwVersion = sVal;
				cVersion_u = cUFlag;
		}


		/**
		 * 获取 版本号   
		 * 
		 * @return dwVersion value 类型为:uint32_t
		 * 
		 */
		 const uint32_t&  GetVersion() const {
				return dwVersion;
		}


		/**
		 * 是否设置库存盘点明细SysNo了
		 * 
		 * @param uint64_t:ddwStockCheckItemSysNo
		 *  
		 * 
		 */
		 bool  IsStockCheckItemSysNoSet() const{
				 return  cStockCheckItemSysNo_u != 0;
		}


		/**
		 * 获取uflag库存盘点明细SysNo了
		 * 
		 * @param uint64_t:ddwStockCheckItemSysNo
		 *  
		 * 
		 */
		 const uint8_t   GetStockCheckItemSysNoUFlag() const{
				 return  cStockCheckItemSysNo_u;
		}


		/**
		 * 设置库存盘点明细SysNo
		 * 
		 * @param uint64_t:ddwStockCheckItemSysNo
		 *  
		 * 
		 */
		 void  SetStockCheckItemSysNo( const uint64_t& sVal, uint8_t cUFlag=1){
				ddwStockCheckItemSysNo = sVal;
				cStockCheckItemSysNo_u = cUFlag;
		}


		/**
		 * 获取库存盘点明细SysNo
		 * 
		 * @return ddwStockCheckItemSysNo value 类型为:uint64_t
		 * 
		 */
		 const uint64_t&  GetStockCheckItemSysNo() const {
				return ddwStockCheckItemSysNo;
		}


		/**
		 * 是否设置商品SysNo了
		 * 
		 * @param uint64_t:ddwProductSysNo
		 *  
		 * 
		 */
		 bool  IsProductSysNoSet() const{
				 return  cProductSysNo_u != 0;
		}


		/**
		 * 获取uflag商品SysNo了
		 * 
		 * @param uint64_t:ddwProductSysNo
		 *  
		 * 
		 */
		 const uint8_t   GetProductSysNoUFlag() const{
				 return  cProductSysNo_u;
		}


		/**
		 * 设置商品SysNo
		 * 
		 * @param uint64_t:ddwProductSysNo
		 *  
		 * 
		 */
		 void  SetProductSysNo( const uint64_t& sVal, uint8_t cUFlag=1){
				ddwProductSysNo = sVal;
				cProductSysNo_u = cUFlag;
		}


		/**
		 * 获取商品SysNo
		 * 
		 * @return ddwProductSysNo value 类型为:uint64_t
		 * 
		 */
		 const uint64_t&  GetProductSysNo() const {
				return ddwProductSysNo;
		}


		/**
		 * 是否设置盘点单SysNo了
		 * 
		 * @param uint64_t:ddwStockCheckMasterSysNo
		 *  
		 * 
		 */
		 bool  IsStockCheckMasterSysNoSet() const{
				 return  cStockCheckMasterSysNo_u != 0;
		}


		/**
		 * 获取uflag盘点单SysNo了
		 * 
		 * @param uint64_t:ddwStockCheckMasterSysNo
		 *  
		 * 
		 */
		 const uint8_t   GetStockCheckMasterSysNoUFlag() const{
				 return  cStockCheckMasterSysNo_u;
		}


		/**
		 * 设置盘点单SysNo
		 * 
		 * @param uint64_t:ddwStockCheckMasterSysNo
		 *  
		 * 
		 */
		 void  SetStockCheckMasterSysNo( const uint64_t& sVal, uint8_t cUFlag=1){
				ddwStockCheckMasterSysNo = sVal;
				cStockCheckMasterSysNo_u = cUFlag;
		}


		/**
		 * 获取盘点单SysNo
		 * 
		 * @return ddwStockCheckMasterSysNo value 类型为:uint64_t
		 * 
		 */
		 const uint64_t&  GetStockCheckMasterSysNo() const {
				return ddwStockCheckMasterSysNo;
		}


		/**
		 * 是否设置库位SysNo了
		 * 
		 * @param uint64_t:ddwStorageSysNo
		 *  
		 * 
		 */
		 bool  IsStorageSysNoSet() const{
				 return  cStorageSysNo_u != 0;
		}


		/**
		 * 获取uflag库位SysNo了
		 * 
		 * @param uint64_t:ddwStorageSysNo
		 *  
		 * 
		 */
		 const uint8_t   GetStorageSysNoUFlag() const{
				 return  cStorageSysNo_u;
		}


		/**
		 * 设置库位SysNo
		 * 
		 * @param uint64_t:ddwStorageSysNo
		 *  
		 * 
		 */
		 void  SetStorageSysNo( const uint64_t& sVal, uint8_t cUFlag=1){
				ddwStorageSysNo = sVal;
				cStorageSysNo_u = cUFlag;
		}


		/**
		 * 获取库位SysNo
		 * 
		 * @return ddwStorageSysNo value 类型为:uint64_t
		 * 
		 */
		 const uint64_t&  GetStorageSysNo() const {
				return ddwStorageSysNo;
		}


		/**
		 * 是否设置盘点数量了
		 * 
		 * @param uint32_t:dwCheckQty
		 *  
		 * 
		 */
		 bool  IsCheckQtySet() const{
				 return  cCheckQty_u != 0;
		}


		/**
		 * 获取uflag盘点数量了
		 * 
		 * @param uint32_t:dwCheckQty
		 *  
		 * 
		 */
		 const uint8_t   GetCheckQtyUFlag() const{
				 return  cCheckQty_u;
		}


		/**
		 * 设置盘点数量
		 * 
		 * @param uint32_t:dwCheckQty
		 *  
		 * 
		 */
		 void  SetCheckQty( const uint32_t& sVal, uint8_t cUFlag=1){
				dwCheckQty = sVal;
				cCheckQty_u = cUFlag;
		}


		/**
		 * 获取盘点数量
		 * 
		 * @return dwCheckQty value 类型为:uint32_t
		 * 
		 */
		 const uint32_t&  GetCheckQty() const {
				return dwCheckQty;
		}


		/**
		 * 是否设置商品成本价了
		 * 
		 * @param uint64_t:ddwCostPrice
		 *  
		 * 
		 */
		 bool  IsCostPriceSet() const{
				 return  cCostPrice_u != 0;
		}


		/**
		 * 获取uflag商品成本价了
		 * 
		 * @param uint64_t:ddwCostPrice
		 *  
		 * 
		 */
		 const uint8_t   GetCostPriceUFlag() const{
				 return  cCostPrice_u;
		}


		/**
		 * 设置商品成本价
		 * 
		 * @param uint64_t:ddwCostPrice
		 *  
		 * 
		 */
		 void  SetCostPrice( const uint64_t& sVal, uint8_t cUFlag=1){
				ddwCostPrice = sVal;
				cCostPrice_u = cUFlag;
		}


		/**
		 * 获取商品成本价
		 * 
		 * @return ddwCostPrice value 类型为:uint64_t
		 * 
		 */
		 const uint64_t&  GetCostPrice() const {
				return ddwCostPrice;
		}


		/**
		 * 是否设置商品成本总价了
		 * 
		 * @param uint64_t:ddwCostAmount
		 *  
		 * 
		 */
		 bool  IsCostAmountSet() const{
				 return  cCostAmount_u != 0;
		}


		/**
		 * 获取uflag商品成本总价了
		 * 
		 * @param uint64_t:ddwCostAmount
		 *  
		 * 
		 */
		 const uint8_t   GetCostAmountUFlag() const{
				 return  cCostAmount_u;
		}


		/**
		 * 设置商品成本总价
		 * 
		 * @param uint64_t:ddwCostAmount
		 *  
		 * 
		 */
		 void  SetCostAmount( const uint64_t& sVal, uint8_t cUFlag=1){
				ddwCostAmount = sVal;
				cCostAmount_u = cUFlag;
		}


		/**
		 * 获取商品成本总价
		 * 
		 * @return ddwCostAmount value 类型为:uint64_t
		 * 
		 */
		 const uint64_t&  GetCostAmount() const {
				return ddwCostAmount;
		}


		/**
		 * 是否设置库存数量了
		 * 
		 * @param uint32_t:dwStockQty
		 *  
		 * 
		 */
		 bool  IsStockQtySet() const{
				 return  cStockQty_u != 0;
		}


		/**
		 * 获取uflag库存数量了
		 * 
		 * @param uint32_t:dwStockQty
		 *  
		 * 
		 */
		 const uint8_t   GetStockQtyUFlag() const{
				 return  cStockQty_u;
		}


		/**
		 * 设置库存数量
		 * 
		 * @param uint32_t:dwStockQty
		 *  
		 * 
		 */
		 void  SetStockQty( const uint32_t& sVal, uint8_t cUFlag=1){
				dwStockQty = sVal;
				cStockQty_u = cUFlag;
		}


		/**
		 * 获取库存数量
		 * 
		 * @return dwStockQty value 类型为:uint32_t
		 * 
		 */
		 const uint32_t&  GetStockQty() const {
				return dwStockQty;
		}


		/**
		 * 是否设置仓位空间了
		 * 
		 * @param std::string:strCargoSpace
		 *  
		 * 
		 */
		 bool  IsCargoSpaceSet() const{
				 return  cCargoSpace_u != 0;
		}


		/**
		 * 获取uflag仓位空间了
		 * 
		 * @param std::string:strCargoSpace
		 *  
		 * 
		 */
		 const uint8_t   GetCargoSpaceUFlag() const{
				 return  cCargoSpace_u;
		}


		/**
		 * 设置仓位空间
		 * 
		 * @param std::string:strCargoSpace
		 *  
		 * 
		 */
		 void  SetCargoSpace( const std::string& sVal, uint8_t cUFlag=1){
				strCargoSpace = sVal;
				cCargoSpace_u = cUFlag;
		}


		/**
		 * 获取仓位空间
		 * 
		 * @return strCargoSpace value 类型为:std::string
		 * 
		 */
		 const std::string&  GetCargoSpace() const {
				return strCargoSpace;
		}


		/**
		 * 获取仓位空间
		 * 
		 * @return strCargoSpace value 类型为:std::string
		 * 
		 */
		 std::string&  GetCargoSpace() {
				return strCargoSpace;
		}


		/**
		 * 是否设置创建时间了
		 * 
		 * @param uint32_t:dwRowCreatDate
		 *  
		 * 
		 */
		 bool  IsRowCreatDateSet() const{
				 return  cRowCreatDate_u != 0;
		}


		/**
		 * 获取uflag创建时间了
		 * 
		 * @param uint32_t:dwRowCreatDate
		 *  
		 * 
		 */
		 const uint8_t   GetRowCreatDateUFlag() const{
				 return  cRowCreatDate_u;
		}


		/**
		 * 设置创建时间
		 * 
		 * @param uint32_t:dwRowCreatDate
		 *  
		 * 
		 */
		 void  SetRowCreatDate( const uint32_t& sVal, uint8_t cUFlag=1){
				dwRowCreatDate = sVal;
				cRowCreatDate_u = cUFlag;
		}


		/**
		 * 获取创建时间
		 * 
		 * @return dwRowCreatDate value 类型为:uint32_t
		 * 
		 */
		 const uint32_t&  GetRowCreatDate() const {
				return dwRowCreatDate;
		}


		/**
		 * 是否设置创建人SysNo了
		 * 
		 * @param uint64_t:ddwCreatorSysNo
		 *  
		 * 
		 */
		 bool  IsCreatorSysNoSet() const{
				 return  cCreatorSysNo_u != 0;
		}


		/**
		 * 获取uflag创建人SysNo了
		 * 
		 * @param uint64_t:ddwCreatorSysNo
		 *  
		 * 
		 */
		 const uint8_t   GetCreatorSysNoUFlag() const{
				 return  cCreatorSysNo_u;
		}


		/**
		 * 设置创建人SysNo
		 * 
		 * @param uint64_t:ddwCreatorSysNo
		 *  
		 * 
		 */
		 void  SetCreatorSysNo( const uint64_t& sVal, uint8_t cUFlag=1){
				ddwCreatorSysNo = sVal;
				cCreatorSysNo_u = cUFlag;
		}


		/**
		 * 获取创建人SysNo
		 * 
		 * @return ddwCreatorSysNo value 类型为:uint64_t
		 * 
		 */
		 const uint64_t&  GetCreatorSysNo() const {
				return ddwCreatorSysNo;
		}


		/**
		 * 是否设置修改人SysNo了
		 * 
		 * @param uint64_t:ddwModifyUserSysNo
		 *  
		 * 
		 */
		 bool  IsModifyUserSysNoSet() const{
				 return  cModifyUserSysNo_u != 0;
		}


		/**
		 * 获取uflag修改人SysNo了
		 * 
		 * @param uint64_t:ddwModifyUserSysNo
		 *  
		 * 
		 */
		 const uint8_t   GetModifyUserSysNoUFlag() const{
				 return  cModifyUserSysNo_u;
		}


		/**
		 * 设置修改人SysNo
		 * 
		 * @param uint64_t:ddwModifyUserSysNo
		 *  
		 * 
		 */
		 void  SetModifyUserSysNo( const uint64_t& sVal, uint8_t cUFlag=1){
				ddwModifyUserSysNo = sVal;
				cModifyUserSysNo_u = cUFlag;
		}


		/**
		 * 获取修改人SysNo
		 * 
		 * @return ddwModifyUserSysNo value 类型为:uint64_t
		 * 
		 */
		 const uint64_t&  GetModifyUserSysNo() const {
				return ddwModifyUserSysNo;
		}


		/**
		 * 是否设置修改时间了
		 * 
		 * @param uint32_t:dwModifyTime
		 *  
		 * 
		 */
		 bool  IsModifyTimeSet() const{
				 return  cModifyTime_u != 0;
		}


		/**
		 * 获取uflag修改时间了
		 * 
		 * @param uint32_t:dwModifyTime
		 *  
		 * 
		 */
		 const uint8_t   GetModifyTimeUFlag() const{
				 return  cModifyTime_u;
		}


		/**
		 * 设置修改时间
		 * 
		 * @param uint32_t:dwModifyTime
		 *  
		 * 
		 */
		 void  SetModifyTime( const uint32_t& sVal, uint8_t cUFlag=1){
				dwModifyTime = sVal;
				cModifyTime_u = cUFlag;
		}


		/**
		 * 获取修改时间
		 * 
		 * @return dwModifyTime value 类型为:uint32_t
		 * 
		 */
		 const uint32_t&  GetModifyTime() const {
				return dwModifyTime;
		}


		/**
		 * 是否设置盘点明细状态了
		 * 
		 * @param uint32_t:dwStockCheckItemStatus
		 *  
		 * 
		 */
		 bool  IsStockCheckItemStatusSet() const{
				 return  cStockCheckItemStatus_u != 0;
		}


		/**
		 * 获取uflag盘点明细状态了
		 * 
		 * @param uint32_t:dwStockCheckItemStatus
		 *  
		 * 
		 */
		 const uint8_t   GetStockCheckItemStatusUFlag() const{
				 return  cStockCheckItemStatus_u;
		}


		/**
		 * 设置盘点明细状态
		 * 
		 * @param uint32_t:dwStockCheckItemStatus
		 *  
		 * 
		 */
		 void  SetStockCheckItemStatus( const uint32_t& sVal, uint8_t cUFlag=1){
				dwStockCheckItemStatus = sVal;
				cStockCheckItemStatus_u = cUFlag;
		}


		/**
		 * 获取盘点明细状态
		 * 
		 * @return dwStockCheckItemStatus value 类型为:uint32_t
		 * 
		 */
		 const uint32_t&  GetStockCheckItemStatus() const {
				return dwStockCheckItemStatus;
		}


		/**
		 * 是否设置盘点明细属性,只读了
		 * 
		 * @param std::bitset<32> :bitsetStockCheckItemProperty
		 *  
		 * 
		 */
		 bool  IsStockCheckItemPropertySet() const{
				 return  cStockCheckItemProperty_u != 0;
		}


		/**
		 * 获取uflag盘点明细属性,只读了
		 * 
		 * @param std::bitset<32> :bitsetStockCheckItemProperty
		 *  
		 * 
		 */
		 const uint8_t   GetStockCheckItemPropertyUFlag() const{
				 return  cStockCheckItemProperty_u;
		}


		/**
		 * 设置盘点明细属性,只读
		 * 
		 * @param std::bitset<32> :bitsetStockCheckItemProperty
		 *  
		 * 
		 */
		 void  SetStockCheckItemProperty( const std::bitset<32> & sVal, uint8_t cUFlag=1){
				bitsetStockCheckItemProperty = sVal;
				cStockCheckItemProperty_u = cUFlag;
		}


		/**
		 * 获取盘点明细属性,只读
		 * 
		 * @return bitsetStockCheckItemProperty value 类型为:std::bitset<32> 
		 * 
		 */
		 const std::bitset<32> &  GetStockCheckItemProperty() const {
				return bitsetStockCheckItemProperty;
		}


		/**
		 * 获取盘点明细属性,只读
		 * 
		 * @return bitsetStockCheckItemProperty value 类型为:std::bitset<32> 
		 * 
		 */
		 std::bitset<32> &  GetStockCheckItemProperty() {
				return bitsetStockCheckItemProperty;
		}


		/**
		 * 是否设置盘点明细属性,设置了
		 * 
		 * @param std::bitset<32> :bitsetStockCheckItemPropertyInclude
		 *  
		 * 
		 */
		 bool  IsStockCheckItemPropertyIncludeSet() const{
				 return  cStockCheckItemPropertyInclude_u != 0;
		}


		/**
		 * 获取uflag盘点明细属性,设置了
		 * 
		 * @param std::bitset<32> :bitsetStockCheckItemPropertyInclude
		 *  
		 * 
		 */
		 const uint8_t   GetStockCheckItemPropertyIncludeUFlag() const{
				 return  cStockCheckItemPropertyInclude_u;
		}


		/**
		 * 设置盘点明细属性,设置
		 * 
		 * @param std::bitset<32> :bitsetStockCheckItemPropertyInclude
		 *  
		 * 
		 */
		 void  SetStockCheckItemPropertyInclude( const std::bitset<32> & sVal, uint8_t cUFlag=1){
				bitsetStockCheckItemPropertyInclude = sVal;
				cStockCheckItemPropertyInclude_u = cUFlag;
		}


		/**
		 * 获取盘点明细属性,设置
		 * 
		 * @return bitsetStockCheckItemPropertyInclude value 类型为:std::bitset<32> 
		 * 
		 */
		 const std::bitset<32> &  GetStockCheckItemPropertyInclude() const {
				return bitsetStockCheckItemPropertyInclude;
		}


		/**
		 * 获取盘点明细属性,设置
		 * 
		 * @return bitsetStockCheckItemPropertyInclude value 类型为:std::bitset<32> 
		 * 
		 */
		 std::bitset<32> &  GetStockCheckItemPropertyInclude() {
				return bitsetStockCheckItemPropertyInclude;
		}


		/**
		 * 是否设置盘点明细属性,取消了
		 * 
		 * @param std::bitset<32> :bitsetStockCheckItemPropertyExclude
		 *  
		 * 
		 */
		 bool  IsStockCheckItemPropertyExcludeSet() const{
				 return  cStockCheckItemPropertyExclude_u != 0;
		}


		/**
		 * 获取uflag盘点明细属性,取消了
		 * 
		 * @param std::bitset<32> :bitsetStockCheckItemPropertyExclude
		 *  
		 * 
		 */
		 const uint8_t   GetStockCheckItemPropertyExcludeUFlag() const{
				 return  cStockCheckItemPropertyExclude_u;
		}


		/**
		 * 设置盘点明细属性,取消
		 * 
		 * @param std::bitset<32> :bitsetStockCheckItemPropertyExclude
		 *  
		 * 
		 */
		 void  SetStockCheckItemPropertyExclude( const std::bitset<32> & sVal, uint8_t cUFlag=1){
				bitsetStockCheckItemPropertyExclude = sVal;
				cStockCheckItemPropertyExclude_u = cUFlag;
		}


		/**
		 * 获取盘点明细属性,取消
		 * 
		 * @return bitsetStockCheckItemPropertyExclude value 类型为:std::bitset<32> 
		 * 
		 */
		 const std::bitset<32> &  GetStockCheckItemPropertyExclude() const {
				return bitsetStockCheckItemPropertyExclude;
		}


		/**
		 * 获取盘点明细属性,取消
		 * 
		 * @return bitsetStockCheckItemPropertyExclude value 类型为:std::bitset<32> 
		 * 
		 */
		 std::bitset<32> &  GetStockCheckItemPropertyExclude() {
				return bitsetStockCheckItemPropertyExclude;
		}

		virtual bool Serialize(CByteStreamNetwork& bs){
		
			uint32_t dwMyLen = 0;
			if(bs.isStoring()) //for write in buffer
			{
				//can not larger than 1 M.
				CByteStreamNetwork bsDummy(NULL, 1024 * 1024, false);
				//bsDummy for precheck the xo size...
				bsDummy.isStoring(true);
				Serialize_i(bsDummy);
				dwMyLen = bsDummy.getWrittenLength();
				bs & dwMyLen;
				Serialize_i(bs);
			}
			else
			{    //for read from buffer
				bs & dwMyLen;
				uint32_t dwReadedLen = bs.getReadLength();
				Serialize_i(bs);
				dwReadedLen = bs.getReadLength() - dwReadedLen;
				// dwReadedLen for the size of xo
				if( dwReadedLen > dwMyLen ){
					return false;
				}
				//go through the unwanted mem position...
				bs.goForward( dwMyLen - dwReadedLen );
			}

			return bs.isGood();
		}

		bool Serialize_i(CByteStreamNetwork& bsTmp){

			bsTmp & dwVersion; // 序列化 版本号    类型为uint32_t
			bsTmp & cVersion_u; // 序列化uflag 类型为uint8_t
			bsTmp & ddwStockCheckItemSysNo; // 序列化库存盘点明细SysNo 类型为uint64_t
			bsTmp & cStockCheckItemSysNo_u; // 序列化uflag 类型为uint8_t
			bsTmp & ddwProductSysNo; // 序列化商品SysNo 类型为uint64_t
			bsTmp & cProductSysNo_u; // 序列化uflag 类型为uint8_t
			bsTmp & ddwStockCheckMasterSysNo; // 序列化盘点单SysNo 类型为uint64_t
			bsTmp & cStockCheckMasterSysNo_u; // 序列化uflag 类型为uint8_t
			bsTmp & ddwStorageSysNo; // 序列化库位SysNo 类型为uint64_t
			bsTmp & cStorageSysNo_u; // 序列化uflag 类型为uint8_t
			bsTmp & dwCheckQty; // 序列化盘点数量 类型为uint32_t
			bsTmp & cCheckQty_u; // 序列化uflag 类型为uint8_t
			bsTmp & ddwCostPrice; // 序列化商品成本价 类型为uint64_t
			bsTmp & cCostPrice_u; // 序列化uflag 类型为uint8_t
			bsTmp & ddwCostAmount; // 序列化商品成本总价 类型为uint64_t
			bsTmp & cCostAmount_u; // 序列化uflag 类型为uint8_t
			bsTmp & dwStockQty; // 序列化库存数量 类型为uint32_t
			bsTmp & cStockQty_u; // 序列化uflag 类型为uint8_t
			bsTmp & strCargoSpace; // 序列化仓位空间 类型为String
			bsTmp & cCargoSpace_u; // 序列化uflag 类型为uint8_t
			bsTmp & dwRowCreatDate; // 序列化创建时间 类型为uint32_t
			bsTmp & cRowCreatDate_u; // 序列化uflag 类型为uint8_t
			bsTmp & ddwCreatorSysNo; // 序列化创建人SysNo 类型为uint64_t
			bsTmp & cCreatorSysNo_u; // 序列化uflag 类型为uint8_t
			bsTmp & ddwModifyUserSysNo; // 序列化修改人SysNo 类型为uint64_t
			bsTmp & cModifyUserSysNo_u; // 序列化uflag 类型为uint8_t
			bsTmp & dwModifyTime; // 序列化修改时间 类型为uint32_t
			bsTmp & cModifyTime_u; // 序列化uflag 类型为uint8_t
			bsTmp & dwStockCheckItemStatus; // 序列化盘点明细状态 类型为uint32_t
			bsTmp & cStockCheckItemStatus_u; // 序列化uflag 类型为uint8_t
			bsTmp & bitsetStockCheckItemProperty; // 序列化盘点明细属性,只读 类型为BitSet
			bsTmp & cStockCheckItemProperty_u; // 序列化uflag 类型为uint8_t
			bsTmp & bitsetStockCheckItemPropertyInclude; // 序列化盘点明细属性,设置 类型为BitSet
			bsTmp & cStockCheckItemPropertyInclude_u; // 序列化uflag 类型为uint8_t
			bsTmp & bitsetStockCheckItemPropertyExclude; // 序列化盘点明细属性,取消 类型为BitSet
			bsTmp & cStockCheckItemPropertyExclude_u; // 序列化uflag 类型为uint8_t
			return bsTmp.isGood();
		}

		const char* GetLastErrMsg() const{
			return m_sLastErrMsg.c_str();
		}

		bool VerifyStockCheckItemDdo(){

			if(!IsVersionSet()){
				m_sLastErrMsg = "Miss Param:version";
				return false;
			}

			if(!IsStockCheckItemSysNoSet()){
				m_sLastErrMsg = "Miss Param:stockCheckItemSysNo";
				return false;
			}

			if(!IsProductSysNoSet()){
				m_sLastErrMsg = "Miss Param:productSysNo";
				return false;
			}

			if(!IsStockCheckMasterSysNoSet()){
				m_sLastErrMsg = "Miss Param:stockCheckMasterSysNo";
				return false;
			}

			if(!IsStorageSysNoSet()){
				m_sLastErrMsg = "Miss Param:storageSysNo";
				return false;
			}

			if(!IsCheckQtySet()){
				m_sLastErrMsg = "Miss Param:checkQty";
				return false;
			}

			if(!IsCostPriceSet()){
				m_sLastErrMsg = "Miss Param:costPrice";
				return false;
			}

			if(!IsCostAmountSet()){
				m_sLastErrMsg = "Miss Param:costAmount";
				return false;
			}

			if(!IsStockQtySet()){
				m_sLastErrMsg = "Miss Param:stockQty";
				return false;
			}

			if(!IsCargoSpaceSet()){
				m_sLastErrMsg = "Miss Param:cargoSpace";
				return false;
			}

			if(!IsRowCreatDateSet()){
				m_sLastErrMsg = "Miss Param:rowCreatDate";
				return false;
			}

			if(!IsCreatorSysNoSet()){
				m_sLastErrMsg = "Miss Param:creatorSysNo";
				return false;
			}

			if(!IsModifyUserSysNoSet()){
				m_sLastErrMsg = "Miss Param:modifyUserSysNo";
				return false;
			}

			if(!IsModifyTimeSet()){
				m_sLastErrMsg = "Miss Param:modifyTime";
				return false;
			}

			if(!IsStockCheckItemStatusSet()){
				m_sLastErrMsg = "Miss Param:stockCheckItemStatus";
				return false;
			}

			if(!IsStockCheckItemPropertySet()){
				m_sLastErrMsg = "Miss Param:stockCheckItemProperty";
				return false;
			}

			if(!IsStockCheckItemPropertyIncludeSet()){
				m_sLastErrMsg = "Miss Param:stockCheckItemPropertyInclude";
				return false;
			}

			if(!IsStockCheckItemPropertyExcludeSet()){
				m_sLastErrMsg = "Miss Param:stockCheckItemPropertyExclude";
				return false;
			}
			return true;
		}

		void DumpData(std::ostream& oss) const{
		
			oss<<"[dwVersion:"<<dwVersion<<"] ";
			oss<<"[cVersion_u:"<<(int)cVersion_u<<"] ";
			oss<<"[ddwStockCheckItemSysNo:"<<ddwStockCheckItemSysNo<<"] ";
			oss<<"[cStockCheckItemSysNo_u:"<<(int)cStockCheckItemSysNo_u<<"] ";
			oss<<"[ddwProductSysNo:"<<ddwProductSysNo<<"] ";
			oss<<"[cProductSysNo_u:"<<(int)cProductSysNo_u<<"] ";
			oss<<"[ddwStockCheckMasterSysNo:"<<ddwStockCheckMasterSysNo<<"] ";
			oss<<"[cStockCheckMasterSysNo_u:"<<(int)cStockCheckMasterSysNo_u<<"] ";
			oss<<"[ddwStorageSysNo:"<<ddwStorageSysNo<<"] ";
			oss<<"[cStorageSysNo_u:"<<(int)cStorageSysNo_u<<"] ";
			oss<<"[dwCheckQty:"<<dwCheckQty<<"] ";
			oss<<"[cCheckQty_u:"<<(int)cCheckQty_u<<"] ";
			oss<<"[ddwCostPrice:"<<ddwCostPrice<<"] ";
			oss<<"[cCostPrice_u:"<<(int)cCostPrice_u<<"] ";
			oss<<"[ddwCostAmount:"<<ddwCostAmount<<"] ";
			oss<<"[cCostAmount_u:"<<(int)cCostAmount_u<<"] ";
			oss<<"[dwStockQty:"<<dwStockQty<<"] ";
			oss<<"[cStockQty_u:"<<(int)cStockQty_u<<"] ";
			oss<<"[strCargoSpace:"<<strCargoSpace<<"] ";
			oss<<"[cCargoSpace_u:"<<(int)cCargoSpace_u<<"] ";
			oss<<"[dwRowCreatDate:"<<dwRowCreatDate<<"] ";
			oss<<"[cRowCreatDate_u:"<<(int)cRowCreatDate_u<<"] ";
			oss<<"[ddwCreatorSysNo:"<<ddwCreatorSysNo<<"] ";
			oss<<"[cCreatorSysNo_u:"<<(int)cCreatorSysNo_u<<"] ";
			oss<<"[ddwModifyUserSysNo:"<<ddwModifyUserSysNo<<"] ";
			oss<<"[cModifyUserSysNo_u:"<<(int)cModifyUserSysNo_u<<"] ";
			oss<<"[dwModifyTime:"<<dwModifyTime<<"] ";
			oss<<"[cModifyTime_u:"<<(int)cModifyTime_u<<"] ";
			oss<<"[dwStockCheckItemStatus:"<<dwStockCheckItemStatus<<"] ";
			oss<<"[cStockCheckItemStatus_u:"<<(int)cStockCheckItemStatus_u<<"] ";
		//嵌套内容有错误，建议使用dumpDataTree方法，复杂数据格式更直观！
			oss<<"[cStockCheckItemProperty_u:"<<(int)cStockCheckItemProperty_u<<"] ";
		//嵌套内容有错误，建议使用dumpDataTree方法，复杂数据格式更直观！
			oss<<"[cStockCheckItemPropertyInclude_u:"<<(int)cStockCheckItemPropertyInclude_u<<"] ";
		//嵌套内容有错误，建议使用dumpDataTree方法，复杂数据格式更直观！
			oss<<"[cStockCheckItemPropertyExclude_u:"<<(int)cStockCheckItemPropertyExclude_u<<"] ";
		
		}

		// codydeng提供,非常好的dump方法 ^-^  。。。。。
		template<typename T>
		T & DumpPlusData(T& oss){
			oss<<"dwVersion:"<<dwVersion;
			oss<<"[cVersion_u:"<<cVersion_u<<"] ";
			oss<<"ddwStockCheckItemSysNo:"<<ddwStockCheckItemSysNo;
			oss<<"[cStockCheckItemSysNo_u:"<<cStockCheckItemSysNo_u<<"] ";
			oss<<"ddwProductSysNo:"<<ddwProductSysNo;
			oss<<"[cProductSysNo_u:"<<cProductSysNo_u<<"] ";
			oss<<"ddwStockCheckMasterSysNo:"<<ddwStockCheckMasterSysNo;
			oss<<"[cStockCheckMasterSysNo_u:"<<cStockCheckMasterSysNo_u<<"] ";
			oss<<"ddwStorageSysNo:"<<ddwStorageSysNo;
			oss<<"[cStorageSysNo_u:"<<cStorageSysNo_u<<"] ";
			oss<<"dwCheckQty:"<<dwCheckQty;
			oss<<"[cCheckQty_u:"<<cCheckQty_u<<"] ";
			oss<<"ddwCostPrice:"<<ddwCostPrice;
			oss<<"[cCostPrice_u:"<<cCostPrice_u<<"] ";
			oss<<"ddwCostAmount:"<<ddwCostAmount;
			oss<<"[cCostAmount_u:"<<cCostAmount_u<<"] ";
			oss<<"dwStockQty:"<<dwStockQty;
			oss<<"[cStockQty_u:"<<cStockQty_u<<"] ";
			oss<<"strCargoSpace:"<<strCargoSpace;
			oss<<"[cCargoSpace_u:"<<cCargoSpace_u<<"] ";
			oss<<"dwRowCreatDate:"<<dwRowCreatDate;
			oss<<"[cRowCreatDate_u:"<<cRowCreatDate_u<<"] ";
			oss<<"ddwCreatorSysNo:"<<ddwCreatorSysNo;
			oss<<"[cCreatorSysNo_u:"<<cCreatorSysNo_u<<"] ";
			oss<<"ddwModifyUserSysNo:"<<ddwModifyUserSysNo;
			oss<<"[cModifyUserSysNo_u:"<<cModifyUserSysNo_u<<"] ";
			oss<<"dwModifyTime:"<<dwModifyTime;
			oss<<"[cModifyTime_u:"<<cModifyTime_u<<"] ";
			oss<<"dwStockCheckItemStatus:"<<dwStockCheckItemStatus;
			oss<<"[cStockCheckItemStatus_u:"<<cStockCheckItemStatus_u<<"] ";
			oss<<"bitsetStockCheckItemProperty:"<<bitsetStockCheckItemProperty;
			oss<<"[cStockCheckItemProperty_u:"<<cStockCheckItemProperty_u<<"] ";
			oss<<"bitsetStockCheckItemPropertyInclude:"<<bitsetStockCheckItemPropertyInclude;
			oss<<"[cStockCheckItemPropertyInclude_u:"<<cStockCheckItemPropertyInclude_u<<"] ";
			oss<<"bitsetStockCheckItemPropertyExclude:"<<bitsetStockCheckItemPropertyExclude;
			oss<<"[cStockCheckItemPropertyExclude_u:"<<cStockCheckItemPropertyExclude_u<<"] ";
			return oss;
		}

		// wileywang提供,树形dump方法 ^-^  。。。。。
		void DumpDataTree(std::ostream& os, int ident = 0)const {
			g_pprint(os, "dwVersion", dwVersion, ident);
			g_pprint(os, "cVersion_u", cVersion_u, ident);
			g_pprint(os, "ddwStockCheckItemSysNo", ddwStockCheckItemSysNo, ident);
			g_pprint(os, "cStockCheckItemSysNo_u", cStockCheckItemSysNo_u, ident);
			g_pprint(os, "ddwProductSysNo", ddwProductSysNo, ident);
			g_pprint(os, "cProductSysNo_u", cProductSysNo_u, ident);
			g_pprint(os, "ddwStockCheckMasterSysNo", ddwStockCheckMasterSysNo, ident);
			g_pprint(os, "cStockCheckMasterSysNo_u", cStockCheckMasterSysNo_u, ident);
			g_pprint(os, "ddwStorageSysNo", ddwStorageSysNo, ident);
			g_pprint(os, "cStorageSysNo_u", cStorageSysNo_u, ident);
			g_pprint(os, "dwCheckQty", dwCheckQty, ident);
			g_pprint(os, "cCheckQty_u", cCheckQty_u, ident);
			g_pprint(os, "ddwCostPrice", ddwCostPrice, ident);
			g_pprint(os, "cCostPrice_u", cCostPrice_u, ident);
			g_pprint(os, "ddwCostAmount", ddwCostAmount, ident);
			g_pprint(os, "cCostAmount_u", cCostAmount_u, ident);
			g_pprint(os, "dwStockQty", dwStockQty, ident);
			g_pprint(os, "cStockQty_u", cStockQty_u, ident);
			g_pprint(os, "strCargoSpace", strCargoSpace, ident);
			g_pprint(os, "cCargoSpace_u", cCargoSpace_u, ident);
			g_pprint(os, "dwRowCreatDate", dwRowCreatDate, ident);
			g_pprint(os, "cRowCreatDate_u", cRowCreatDate_u, ident);
			g_pprint(os, "ddwCreatorSysNo", ddwCreatorSysNo, ident);
			g_pprint(os, "cCreatorSysNo_u", cCreatorSysNo_u, ident);
			g_pprint(os, "ddwModifyUserSysNo", ddwModifyUserSysNo, ident);
			g_pprint(os, "cModifyUserSysNo_u", cModifyUserSysNo_u, ident);
			g_pprint(os, "dwModifyTime", dwModifyTime, ident);
			g_pprint(os, "cModifyTime_u", cModifyTime_u, ident);
			g_pprint(os, "dwStockCheckItemStatus", dwStockCheckItemStatus, ident);
			g_pprint(os, "cStockCheckItemStatus_u", cStockCheckItemStatus_u, ident);
			g_pprint(os, "bitsetStockCheckItemProperty", bitsetStockCheckItemProperty, ident);
			g_pprint(os, "cStockCheckItemProperty_u", cStockCheckItemProperty_u, ident);
			g_pprint(os, "bitsetStockCheckItemPropertyInclude", bitsetStockCheckItemPropertyInclude, ident);
			g_pprint(os, "cStockCheckItemPropertyInclude_u", cStockCheckItemPropertyInclude_u, ident);
			g_pprint(os, "bitsetStockCheckItemPropertyExclude", bitsetStockCheckItemPropertyExclude, ident);
			g_pprint(os, "cStockCheckItemPropertyExclude_u", cStockCheckItemPropertyExclude_u, ident);
		}
		
		//提供ToString借口，默认为DumpData格式，请按需要进行修改
		std::string ToString() const{
			std::stringstream ss;
			DumpData(ss);
			return ss.str();
		}

/**
 ********************以下信息是每个版本的字段********************
 */

};

}
}
}

#endif /* ERP_STORAGE_DDO_CSTOCKCHECKITEMDDO_BY_AUTOGEN_V5_H */
